home *** CD-ROM | disk | FTP | other *** search
/ BCI NET 2 / BCI NET 2.iso / archives / programming / source / graphicgems4.lha / GemsIV / vec_mat / algebra3.h < prev    next >
Encoding:
C/C++ Source or Header  |  1995-02-06  |  12.8 KB  |  366 lines
  1. /****************************************************************
  2. *                                *
  3. * C++ Vector and Matrix Algebra routines            *
  4. * Author: Jean-Francois DOUE                    *
  5. * Version 3.1 --- October 1993                    *
  6. *                                *
  7. ****************************************************************/
  8.  
  9. #include <stream.h>
  10. #include <stdlib.h>
  11.  
  12. // this line defines a new type: pointer to a function which returns a
  13. // double and takes as argument a double
  14. typedef double (*V_FCT_PTR)(double);
  15.  
  16. // min-max macros
  17. #define MIN(A,B) ((A) < (B) ? (A) : (B))
  18. #define MAX(A,B) ((A) > (B) ? (A) : (B))
  19.  
  20. // error handling macro
  21. #define V_ERROR(E) { cerr << E; exit(1); }
  22.  
  23. class vec2;
  24. class vec3;
  25. class vec4;
  26. class mat3;
  27. class mat4;
  28.  
  29. enum {VX, VY, VZ, VW};            // axes
  30. enum {PA, PB, PC, PD};            // planes
  31. enum {RED, GREEN, BLUE};        // colors
  32. enum {KA, KD, KS, ES};            // phong coefficients
  33.  
  34. /****************************************************************
  35. *                                *
  36. *                2D Vector                *
  37. *                                *
  38. ****************************************************************/
  39.  
  40. class vec2
  41. {
  42. protected:
  43.  
  44.  double n[2];
  45.  
  46. public:
  47.  
  48. // Constructors
  49.  
  50. vec2();
  51. vec2(const double x, const double y);
  52. vec2(const double d);
  53. vec2(const vec2& v);            // copy constructor
  54. vec2(const vec3& v);            // cast v3 to v2
  55. vec2(const vec3& v, int dropAxis);    // cast v3 to v2
  56.  
  57. // Assignment operators
  58.  
  59. vec2& operator    = ( const vec2& v );    // assignment of a vec2
  60. vec2& operator += ( const vec2& v );    // incrementation by a vec2
  61. vec2& operator -= ( const vec2& v );    // decrementation by a vec2
  62. vec2& operator *= ( const double d );    // multiplication by a constant
  63. vec2& operator /= ( const double d );    // division by a constant
  64. double& operator [] ( int i);        // indexing
  65.  
  66. // special functions
  67.  
  68. double length();            // length of a vec2
  69. double length2();            // squared length of a vec2
  70. vec2& normalize();            // normalize a vec2
  71. vec2& apply(V_FCT_PTR fct);        // apply a func. to each component
  72.  
  73. // friends
  74.  
  75. friend vec2 operator - (const vec2& v);                // -v1
  76. friend vec2 operator + (const vec2& a, const vec2& b);        // v1 + v2
  77. friend vec2 operator - (const vec2& a, const vec2& b);        // v1 - v2
  78. friend vec2 operator * (const vec2& a, const double d);        // v1 * 3.0
  79. friend vec2 operator * (const double d, const vec2& a);        // 3.0 * v1
  80. friend vec2 operator * (const mat3& a, const vec2& v);        // M . v
  81. friend vec2 operator * (const vec2& v, mat3& a);        // v . M
  82. friend double operator * (const vec2& a, const vec2& b);    // dot product
  83. friend vec2 operator / (const vec2& a, const double d);        // v1 / 3.0
  84. friend vec3 operator ^ (const vec2& a, const vec2& b);        // cross product
  85. friend int operator == (const vec2& a, const vec2& b);        // v1 == v2 ?
  86. friend int operator != (const vec2& a, const vec2& b);        // v1 != v2 ?
  87. friend ostream& operator << (ostream& s, vec2& v);        // output to stream
  88. friend istream& operator >> (istream& s, vec2& v);        // input from strm.
  89. friend void swap(vec2& a, vec2& b);                // swap v1 & v2
  90. friend vec2 min(const vec2& a, const vec2& b);            // min(v1, v2)
  91. friend vec2 max(const vec2& a, const vec2& b);            // max(v1, v2)
  92. friend vec2 prod(const vec2& a, const vec2& b);            // term by term *
  93.  
  94. // necessary friend declarations
  95.  
  96. friend class vec3;
  97. };
  98.  
  99. /****************************************************************
  100. *                                *
  101. *                3D Vector                *
  102. *                                *
  103. ****************************************************************/
  104.  
  105. class vec3
  106. {
  107. protected:
  108.  
  109.  double n[3];
  110.  
  111. public:
  112.  
  113. // Constructors
  114.  
  115. vec3();
  116. vec3(const double x, const double y, const double z);
  117. vec3(const double d);
  118. vec3(const vec3& v);                // copy constructor
  119. vec3(const vec2& v);                // cast v2 to v3
  120. vec3(const vec2& v, double d);            // cast v2 to v3
  121. vec3(const vec4& v);                // cast v4 to v3
  122. vec3(const vec4& v, int dropAxis);        // cast v4 to v3
  123.  
  124. // Assignment operators
  125.  
  126. vec3& operator    = ( const vec3& v );        // assignment of a vec3
  127. vec3& operator += ( const vec3& v );        // incrementation by a vec3
  128. vec3& operator -= ( const vec3& v );        // decrementation by a vec3
  129. vec3& operator *= ( const double d );        // multiplication by a constant
  130. vec3& operator /= ( const double d );        // division by a constant
  131. double& operator [] ( int i);            // indexing
  132.  
  133. // special functions
  134.  
  135. double length();                // length of a vec3
  136. double length2();                // squared length of a vec3
  137. vec3& normalize();                // normalize a vec3
  138. vec3& apply(V_FCT_PTR fct);            // apply a func. to each component
  139.  
  140. // friends
  141.  
  142. friend vec3 operator - (const vec3& v);                // -v1
  143. friend vec3 operator + (const vec3& a, const vec3& b);        // v1 + v2
  144. friend vec3 operator - (const vec3& a, const vec3& b);        // v1 - v2
  145. friend vec3 operator * (const vec3& a, const double d);        // v1 * 3.0
  146. friend vec3 operator * (const double d, const vec3& a);        // 3.0 * v1
  147. friend vec3 operator * (const mat4& a, const vec3& v);        // M . v
  148. friend vec3 operator * (const vec3& v, mat4& a);        // v . M
  149. friend double operator * (const vec3& a, const vec3& b);    // dot product
  150. friend vec3 operator / (const vec3& a, const double d);        // v1 / 3.0
  151. friend vec3 operator ^ (const vec3& a, const vec3& b);        // cross product
  152. friend int operator == (const vec3& a, const vec3& b);        // v1 == v2 ?
  153. friend int operator != (const vec3& a, const vec3& b);        // v1 != v2 ?
  154. friend ostream& operator << (ostream& s, vec3& v);        // output to stream
  155. friend istream& operator >> (istream& s, vec3& v);        // input from strm.
  156. friend void swap(vec3& a, vec3& b);                // swap v1 & v2
  157. friend vec3 min(const vec3& a, const vec3& b);            // min(v1, v2)
  158. friend vec3 max(const vec3& a, const vec3& b);            // max(v1, v2)
  159. friend vec3 prod(const vec3& a, const vec3& b);            // term by term *
  160.  
  161. // necessary friend declarations
  162.  
  163. friend class vec2;
  164. friend class vec4;
  165. friend class mat3;
  166. friend vec2 operator * (const mat3& a, const vec2& v);        // linear transform
  167. friend mat3 operator * (mat3& a, mat3& b);            // matrix 3 product
  168. };
  169.  
  170. /****************************************************************
  171. *                                *
  172. *                4D Vector                *
  173. *                                *
  174. ****************************************************************/
  175.  
  176. class vec4
  177. {
  178. protected:
  179.  
  180.  double n[4];
  181.  
  182. public:
  183.  
  184. // Constructors
  185.  
  186. vec4();
  187. vec4(const double x, const double y, const double z, const double w);
  188. vec4(const double d);
  189. vec4(const vec4& v);                // copy constructor
  190. vec4(const vec3& v);                // cast vec3 to vec4
  191. vec4(const vec3& v, const double d);        // cast vec3 to vec4
  192.  
  193. // Assignment operators
  194.  
  195. vec4& operator    = ( const vec4& v );        // assignment of a vec4
  196. vec4& operator += ( const vec4& v );        // incrementation by a vec4
  197. vec4& operator -= ( const vec4& v );        // decrementation by a vec4
  198. vec4& operator *= ( const double d );        // multiplication by a constant
  199. vec4& operator /= ( const double d );        // division by a constant
  200. double& operator [] ( int i);            // indexing
  201.  
  202. // special functions
  203.  
  204. double length();                // length of a vec4
  205. double length2();                // squared length of a vec4
  206. vec4& normalize();                // normalize a vec4
  207. vec4& apply(V_FCT_PTR fct);            // apply a func. to each component
  208.  
  209. // friends
  210.  
  211. friend vec4 operator - (const vec4& v);                // -v1
  212. friend vec4 operator + (const vec4& a, const vec4& b);        // v1 + v2
  213. friend vec4 operator - (const vec4& a, const vec4& b);        // v1 - v2
  214. friend vec4 operator * (const vec4& a, const double d);        // v1 * 3.0
  215. friend vec4 operator * (const double d, const vec4& a);        // 3.0 * v1
  216. friend vec4 operator * (const mat4& a, const vec4& v);        // M . v
  217. friend vec4 operator * (const vec4& v, mat4& a);        // v . M
  218. friend double operator * (const vec4& a, const vec4& b);    // dot product
  219. friend vec4 operator / (const vec4& a, const double d);        // v1 / 3.0
  220. friend int operator == (const vec4& a, const vec4& b);        // v1 == v2 ?
  221. friend int operator != (const vec4& a, const vec4& b);        // v1 != v2 ?
  222. friend ostream& operator << (ostream& s, vec4& v);        // output to stream
  223. friend istream& operator >> (istream& s, vec4& v);        // input from strm.
  224. friend void swap(vec4& a, vec4& b);                // swap v1 & v2
  225. friend vec4 min(const vec4& a, const vec4& b);            // min(v1, v2)
  226. friend vec4 max(const vec4& a, const vec4& b);            // max(v1, v2)
  227. friend vec4 prod(const vec4& a, const vec4& b);            // term by term *
  228.  
  229. // necessary friend declarations
  230.  
  231. friend class vec3;
  232. friend class mat4;
  233. friend vec3 operator * (const mat4& a, const vec3& v);        // linear transform
  234. friend mat4 operator * (mat4& a, mat4& b);            // matrix 4 product
  235. };
  236.  
  237. /****************************************************************
  238. *                                *
  239. *               3x3 Matrix                *
  240. *                                *
  241. ****************************************************************/
  242.  
  243. class mat3
  244. {
  245. protected:
  246.  
  247.  vec3 v[3];
  248.  
  249. public:
  250.  
  251. // Constructors
  252.  
  253. mat3();
  254. mat3(const vec3& v0, const vec3& v1, const vec3& v2);
  255. mat3(const double d);
  256. mat3(const mat3& m);
  257.  
  258. // Assignment operators
  259.  
  260. mat3& operator    = ( const mat3& m );        // assignment of a mat3
  261. mat3& operator += ( const mat3& m );        // incrementation by a mat3
  262. mat3& operator -= ( const mat3& m );        // decrementation by a mat3
  263. mat3& operator *= ( const double d );        // multiplication by a constant
  264. mat3& operator /= ( const double d );        // division by a constant
  265. vec3& operator [] ( int i);            // indexing
  266.  
  267. // special functions
  268.  
  269. mat3 transpose();                // transpose
  270. mat3 inverse();                    // inverse
  271. mat3& apply(V_FCT_PTR fct);            // apply a func. to each element
  272.  
  273. // friends
  274.  
  275. friend mat3 operator - (const mat3& a);                // -m1
  276. friend mat3 operator + (const mat3& a, const mat3& b);        // m1 + m2
  277. friend mat3 operator - (const mat3& a, const mat3& b);        // m1 - m2
  278. friend mat3 operator * (mat3& a, mat3& b);            // m1 * m2
  279. friend mat3 operator * (const mat3& a, const double d);        // m1 * 3.0
  280. friend mat3 operator * (const double d, const mat3& a);        // 3.0 * m1
  281. friend mat3 operator / (const mat3& a, const double d);        // m1 / 3.0
  282. friend int operator == (const mat3& a, const mat3& b);        // m1 == m2 ?
  283. friend int operator != (const mat3& a, const mat3& b);        // m1 != m2 ?
  284. friend ostream& operator << (ostream& s, mat3& m);        // output to stream
  285. friend istream& operator >> (istream& s, mat3& m);        // input from strm.
  286. friend void swap(mat3& a, mat3& b);                // swap m1 & m2
  287.  
  288. // necessary friend declarations
  289.  
  290. friend vec3 operator * (const mat3& a, const vec3& v);        // linear transform
  291. friend vec2 operator * (const mat3& a, const vec2& v);        // linear transform
  292. };
  293.  
  294. /****************************************************************
  295. *                                *
  296. *               4x4 Matrix                *
  297. *                                *
  298. ****************************************************************/
  299.  
  300. class mat4
  301. {
  302. protected:
  303.  
  304.  vec4 v[4];
  305.  
  306. public:
  307.  
  308. // Constructors
  309.  
  310. mat4();
  311. mat4(const vec4& v0, const vec4& v1, const vec4& v2, const vec4& v3);
  312. mat4(const double d);
  313. mat4(const mat4& m);
  314.  
  315. // Assignment operators
  316.  
  317. mat4& operator    = ( const mat4& m );        // assignment of a mat4
  318. mat4& operator += ( const mat4& m );        // incrementation by a mat4
  319. mat4& operator -= ( const mat4& m );        // decrementation by a mat4
  320. mat4& operator *= ( const double d );        // multiplication by a constant
  321. mat4& operator /= ( const double d );        // division by a constant
  322. vec4& operator [] ( int i);            // indexing
  323.  
  324. // special functions
  325.  
  326. mat4 transpose();                // transpose
  327. mat4 inverse();                    // inverse
  328. mat4& apply(V_FCT_PTR fct);            // apply a func. to each element
  329.  
  330. // friends
  331.  
  332. friend mat4 operator - (const mat4& a);                // -m1
  333. friend mat4 operator + (const mat4& a, const mat4& b);        // m1 + m2
  334. friend mat4 operator - (const mat4& a, const mat4& b);        // m1 - m2
  335. friend mat4 operator * (mat4& a, mat4& b);            // m1 * m2
  336. friend mat4 operator * (const mat4& a, const double d);        // m1 * 4.0
  337. friend mat4 operator * (const double d, const mat4& a);        // 4.0 * m1
  338. friend mat4 operator / (const mat4& a, const double d);        // m1 / 3.0
  339. friend int operator == (const mat4& a, const mat4& b);        // m1 == m2 ?
  340. friend int operator != (const mat4& a, const mat4& b);        // m1 != m2 ?
  341. friend ostream& operator << (ostream& s, mat4& m);        // output to stream
  342. friend istream& operator >> (istream& s, mat4& m);        // input from strm.
  343. friend void swap(mat4& a, mat4& b);                // swap m1 & m2
  344.  
  345. // necessary friend declarations
  346.  
  347. friend vec4 operator * (const mat4& a, const vec4& v);        // linear transform
  348. friend vec3 operator * (const mat4& a, const vec3& v);        // linear transform
  349. };
  350.  
  351. /****************************************************************
  352. *                                *
  353. *           2D functions and 3D functions            *
  354. *                                *
  355. ****************************************************************/
  356.  
  357. mat3 identity2D();                        // identity 2D
  358. mat3 translation2D(vec2& v);                    // translation 2D
  359. mat3 rotation2D(vec2& Center, const double angleDeg);        // rotation 2D
  360. mat3 scaling2D(vec2& scaleVector);                // scaling 2D
  361. mat4 identity3D();                        // identity 3D
  362. mat4 translation3D(vec3& v);                    // translation 3D
  363. mat4 rotation3D(vec3& Axis, const double angleDeg);        // rotation 3D
  364. mat4 scaling3D(vec3& scaleVector);                // scaling 3D
  365. mat4 perspective3D(const double d);                // perspective 3D
  366.